package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade SOLICITACAO_ENSAIO
 * @author Gerado pelo Telescope
 */
public class EntSolicitacaoEnsaio extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.SOLICITACAO_ENSAIO";
    public final static String TABLE_NAME = "SOLICITACAO_ENSAIO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntSolicitacaoEnsaio() {
        super();
        initialize();
    }
    
    public EntSolicitacaoEnsaio(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aDataEnsaio = new DomDate(this,"DATA_ENSAIO", "Data planejada para o ensaio"); 
        aDataEnsaio.setRequired(true);
        oDataEnsaio = new DomDate();
        aDataHoraRegistro = new DomDateTime(this,"DATA_HORA_REGISTRO", "Data e hora do registro"); 
        aDataHoraRegistro.setRequired(true);
        aDataHoraRegistro.setDefaultValue("[SYSDATE]");
        oDataHoraRegistro = new DomDateTime();
        aOrdemProducao = new DomText(this,"ORDEM_PRODUCAO", "Ordem de produção"); 
        aOrdemProducao.setSize(32);
        oOrdemProducao = new DomText();
        aOrigemSolicitacao = new DomOption(this,"ORIGEM_SOLICITACAO", "Origem da solicitação"); 
        aOrigemSolicitacao.setRequired(true);
        aOrigemSolicitacao.setSize(1);
        aOrigemSolicitacao.clearOptions();
        aOrigemSolicitacao.addOption("O", "Ordem de produção");
        aOrigemSolicitacao.addOption("T", "Teste");
        aOrigemSolicitacao.setDefaultValue("T");
        oOrigemSolicitacao = new DomOption();
        aSequenciaAutomatica = new DomId(this,"SEQUENCIA_AUTOMATICA", "Sequência automática"); 
        aSequenciaAutomatica.setRequired(true);
        oSequenciaAutomatica = new DomId();
        aModeloHidrometroId = new DomId(this,"MODELO_HIDROMETRO_ID", "Modelo de hidrômetro"); 
        aModeloHidrometroId.setRequired(true);
        oModeloHidrometroId = new DomId();
        aQuantidadeHidrometros = new DomInteger(this,"QUANTIDADE_HIDROMETROS", "Quantidade de hidrômetros"); 
        aQuantidadeHidrometros.setRequired(true);
        oQuantidadeHidrometros = new DomInteger();
        aPlanoExecucaoId = new DomId(this,"PLANO_EXECUCAO_ID", "Plano de execução"); 
        aPlanoExecucaoId.setRequired(true);
        oPlanoExecucaoId = new DomId();
        aSituacao = new DomOption(this,"SITUACAO", "Situação da solicitação"); 
        aSituacao.setRequired(true);
        aSituacao.setSize(1);
        aSituacao.clearOptions();
        aSituacao.addOption("E", "Em execução");
        aSituacao.addOption("F", "Finalizado");
        aSituacao.addOption("P", "Pendente");
        aSituacao.setDefaultValue("P");
        oSituacao = new DomOption();
        aQuantidadeHidrometrosAprovados = new DomInteger(this,"QUANTIDADE_HIDROMETROS_APROVADOS", "Quantidade de hidrômetros aprovados"); 
        aQuantidadeHidrometrosAprovados.setDefaultValue("0");
        oQuantidadeHidrometrosAprovados = new DomInteger();
        aQuantidadeHidrometrosExecucao = new DomInteger(this,"QUANTIDADE_HIDROMETROS_EXECUCAO", "Quantidade de hidrômetros (em execução)"); 
        aQuantidadeHidrometrosExecucao.setDefaultValue("0");
        oQuantidadeHidrometrosExecucao = new DomInteger();
        aQuantidadeHidrometrosPendentes = new DomInteger(this,"QUANTIDADE_HIDROMETROS_PENDENTES", "Quantidade de hidrômetros pendentes"); 
        aQuantidadeHidrometrosPendentes.setDefaultValue("0");
        oQuantidadeHidrometrosPendentes = new DomInteger();
        aQuantidadeHidrometrosReprovados = new DomInteger(this,"QUANTIDADE_HIDROMETROS_REPROVADOS", "Quantidade de hidrômetros reprovados"); 
        aQuantidadeHidrometrosReprovados.setDefaultValue("0");
        oQuantidadeHidrometrosReprovados = new DomInteger();
        aCodigo = new DomText(this,"CODIGO", "Código da solicitação"); 
        aCodigo.setRequired(true);
        aCodigo.setSize(32);
        oCodigo = new DomText();
        aReservaSequencias = new DomFlag(this,"RESERVA_SEQUENCIAS", "Reserva sequencias (nro série)"); 
        aReservaSequencias.setRequired(true);
        aReservaSequencias.setDefaultValue("S");
        oReservaSequencias = new DomFlag();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Data planejada para o ensaio
    private DomDate aDataEnsaio;
    private DomDate oDataEnsaio;
    
    // Data e hora do registro
    private DomDateTime aDataHoraRegistro;
    private DomDateTime oDataHoraRegistro;
    
    // Ordem de produção
    private DomText aOrdemProducao;
    private DomText oOrdemProducao;
    
    // Origem da solicitação
    private DomOption aOrigemSolicitacao;
    private DomOption oOrigemSolicitacao;
    
    // Sequência automática
    private DomId aSequenciaAutomatica;
    private DomId oSequenciaAutomatica;
    
    // Modelo de hidrômetro
    private DomId aModeloHidrometroId;
    private DomId oModeloHidrometroId;
    
    // Quantidade de hidrômetros
    private DomInteger aQuantidadeHidrometros;
    private DomInteger oQuantidadeHidrometros;
    
    // Plano de execução
    private DomId aPlanoExecucaoId;
    private DomId oPlanoExecucaoId;
    
    // Situação da solicitação
    private DomOption aSituacao;
    private DomOption oSituacao;
    
    // Quantidade de hidrômetros aprovados
    private DomInteger aQuantidadeHidrometrosAprovados;
    private DomInteger oQuantidadeHidrometrosAprovados;
    
    // Quantidade de hidrômetros (em execução)
    private DomInteger aQuantidadeHidrometrosExecucao;
    private DomInteger oQuantidadeHidrometrosExecucao;
    
    // Quantidade de hidrômetros pendentes
    private DomInteger aQuantidadeHidrometrosPendentes;
    private DomInteger oQuantidadeHidrometrosPendentes;
    
    // Quantidade de hidrômetros reprovados
    private DomInteger aQuantidadeHidrometrosReprovados;
    private DomInteger oQuantidadeHidrometrosReprovados;
    
    // Código da solicitação
    private DomText aCodigo;
    private DomText oCodigo;
    
    // Reserva sequencias (nro série)
    private DomFlag aReservaSequencias;
    private DomFlag oReservaSequencias;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntSolicitacaoEnsaio id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DATA_ENSAIO">
    
    public EntSolicitacaoEnsaio dataEnsaio(java.sql.Date value) {
        setDataEnsaio(value);
        return this;
    }
    
    public void setDataEnsaio(DomDate value) {
        if (value == null || value.isNull()) {
            nullifyDataEnsaio();
        } else {
            aDataEnsaio.setValue(value.getValue());
            if (aDataEnsaio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataEnsaio(String value) {
        if (value == null) {
            nullifyDataEnsaio();
        } else {
            aDataEnsaio.setValue(value);
            if (aDataEnsaio.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataEnsaio(java.sql.Date value) {
        aDataEnsaio.setValue(value);
        if (aDataEnsaio.isModified()) {
            setModified(true);
        }
    }
    
    public void setDataEnsaio(Object value) {
        aDataEnsaio.setValue(value);
        if (aDataEnsaio.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDataEnsaio() {
        if (!aDataEnsaio.isNull()) {
            aDataEnsaio.setNull(true);
            setModified(true);
        }
    }
    
    public DomDate getDataEnsaio() {
        return aDataEnsaio;
    }
    
    public DomDate oldDataEnsaio() {
        return oDataEnsaio;
    }
    
    public java.sql.Date valueOfDataEnsaio() {
        return aDataEnsaio.getValue();
    }
    
    public boolean isDataEnsaioModified() {
        return aDataEnsaio.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DATA_HORA_REGISTRO">
    
    public EntSolicitacaoEnsaio dataHoraRegistro(java.sql.Timestamp value) {
        setDataHoraRegistro(value);
        return this;
    }
    
    public void setDataHoraRegistro(DomDateTime value) {
        if (value == null || value.isNull()) {
            nullifyDataHoraRegistro();
        } else {
            aDataHoraRegistro.setValue(value.getValue());
            if (aDataHoraRegistro.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataHoraRegistro(String value) {
        if (value == null) {
            nullifyDataHoraRegistro();
        } else {
            aDataHoraRegistro.setValue(value);
            if (aDataHoraRegistro.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataHoraRegistro(java.sql.Timestamp value) {
        aDataHoraRegistro.setValue(value);
        if (aDataHoraRegistro.isModified()) {
            setModified(true);
        }
    }
    
    public void setDataHoraRegistro(Object value) {
        aDataHoraRegistro.setValue(value);
        if (aDataHoraRegistro.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDataHoraRegistro() {
        if (!aDataHoraRegistro.isNull()) {
            aDataHoraRegistro.setNull(true);
            setModified(true);
        }
    }
    
    public DomDateTime getDataHoraRegistro() {
        return aDataHoraRegistro;
    }
    
    public DomDateTime oldDataHoraRegistro() {
        return oDataHoraRegistro;
    }
    
    public java.sql.Timestamp valueOfDataHoraRegistro() {
        return aDataHoraRegistro.getValue();
    }
    
    public boolean isDataHoraRegistroModified() {
        return aDataHoraRegistro.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ORDEM_PRODUCAO">
    
    public EntSolicitacaoEnsaio ordemProducao(String value) {
        setOrdemProducao(value);
        return this;
    }
    
    public void setOrdemProducao(DomText value) {
        if (value == null || value.isNull()) {
            nullifyOrdemProducao();
        } else {
            aOrdemProducao.setValue(value.getValue());
            if (aOrdemProducao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOrdemProducao(String value) {
        if (value == null) {
            nullifyOrdemProducao();
        } else {
            aOrdemProducao.setValue(value);
            if (aOrdemProducao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOrdemProducao(Object value) {
        aOrdemProducao.setValue(value);
        if (aOrdemProducao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyOrdemProducao() {
        if (!aOrdemProducao.isNull()) {
            aOrdemProducao.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getOrdemProducao() {
        return aOrdemProducao;
    }
    
    public DomText oldOrdemProducao() {
        return oOrdemProducao;
    }
    
    public String valueOfOrdemProducao() {
        return aOrdemProducao.getValue();
    }
    
    public boolean isOrdemProducaoModified() {
        return aOrdemProducao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ORIGEM_SOLICITACAO">
    
    public EntSolicitacaoEnsaio origemSolicitacao(String value) {
        setOrigemSolicitacao(value);
        return this;
    }
    
    public void setOrigemSolicitacao(DomOption value) {
        if (value == null || value.isNull()) {
            nullifyOrigemSolicitacao();
        } else {
            aOrigemSolicitacao.setValue(value.getValue());
            if (aOrigemSolicitacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOrigemSolicitacao(String value) {
        if (value == null) {
            nullifyOrigemSolicitacao();
        } else {
            aOrigemSolicitacao.setValue(value);
            if (aOrigemSolicitacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOrigemSolicitacao(Object value) {
        aOrigemSolicitacao.setValue(value);
        if (aOrigemSolicitacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyOrigemSolicitacao() {
        if (!aOrigemSolicitacao.isNull()) {
            aOrigemSolicitacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomOption getOrigemSolicitacao() {
        return aOrigemSolicitacao;
    }
    
    public DomOption oldOrigemSolicitacao() {
        return oOrigemSolicitacao;
    }
    
    public String valueOfOrigemSolicitacao() {
        return aOrigemSolicitacao.getValue();
    }
    
    public boolean isOrigemSolicitacaoModified() {
        return aOrigemSolicitacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SEQUENCIA_AUTOMATICA">
    
    public EntSolicitacaoEnsaio sequenciaAutomatica(Long value) {
        setSequenciaAutomatica(value);
        return this;
    }
    
    public void setSequenciaAutomatica(DomId value) {
        if (value == null || value.isNull()) {
            nullifySequenciaAutomatica();
        } else {
            aSequenciaAutomatica.setValue(value.getValue());
            if (aSequenciaAutomatica.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequenciaAutomatica(String value) {
        if (value == null) {
            nullifySequenciaAutomatica();
        } else {
            aSequenciaAutomatica.setValue(value);
            if (aSequenciaAutomatica.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequenciaAutomatica(Long value) {
        aSequenciaAutomatica.setValue(value);
        if (aSequenciaAutomatica.isModified()) {
            setModified(true);
        }
    }
    
    public void setSequenciaAutomatica(Object value) {
        aSequenciaAutomatica.setValue(value);
        if (aSequenciaAutomatica.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySequenciaAutomatica() {
        if (!aSequenciaAutomatica.isNull()) {
            aSequenciaAutomatica.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getSequenciaAutomatica() {
        return aSequenciaAutomatica;
    }
    
    public DomId oldSequenciaAutomatica() {
        return oSequenciaAutomatica;
    }
    
    public Long valueOfSequenciaAutomatica() {
        return aSequenciaAutomatica.getValue();
    }
    
    public boolean isSequenciaAutomaticaModified() {
        return aSequenciaAutomatica.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MODELO_HIDROMETRO_ID">
    
    public EntSolicitacaoEnsaio modeloHidrometroId(Long value) {
        setModeloHidrometroId(value);
        return this;
    }
    
    public void setModeloHidrometroId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyModeloHidrometroId();
        } else {
            aModeloHidrometroId.setValue(value.getValue());
            if (aModeloHidrometroId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setModeloHidrometroId(String value) {
        if (value == null) {
            nullifyModeloHidrometroId();
        } else {
            aModeloHidrometroId.setValue(value);
            if (aModeloHidrometroId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setModeloHidrometroId(Long value) {
        aModeloHidrometroId.setValue(value);
        if (aModeloHidrometroId.isModified()) {
            setModified(true);
        }
    }
    
    public void setModeloHidrometroId(Object value) {
        aModeloHidrometroId.setValue(value);
        if (aModeloHidrometroId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyModeloHidrometroId() {
        if (!aModeloHidrometroId.isNull()) {
            aModeloHidrometroId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getModeloHidrometroId() {
        return aModeloHidrometroId;
    }
    
    public DomId oldModeloHidrometroId() {
        return oModeloHidrometroId;
    }
    
    public Long valueOfModeloHidrometroId() {
        return aModeloHidrometroId.getValue();
    }
    
    public boolean isModeloHidrometroIdModified() {
        return aModeloHidrometroId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo QUANTIDADE_HIDROMETROS">
    
    public EntSolicitacaoEnsaio quantidadeHidrometros(Integer value) {
        setQuantidadeHidrometros(value);
        return this;
    }
    
    public void setQuantidadeHidrometros(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyQuantidadeHidrometros();
        } else {
            aQuantidadeHidrometros.setValue(value.getValue());
            if (aQuantidadeHidrometros.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometros(String value) {
        if (value == null) {
            nullifyQuantidadeHidrometros();
        } else {
            aQuantidadeHidrometros.setValue(value);
            if (aQuantidadeHidrometros.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometros(Integer value) {
        aQuantidadeHidrometros.setValue(value);
        if (aQuantidadeHidrometros.isModified()) {
            setModified(true);
        }
    }
    
    public void setQuantidadeHidrometros(Object value) {
        aQuantidadeHidrometros.setValue(value);
        if (aQuantidadeHidrometros.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyQuantidadeHidrometros() {
        if (!aQuantidadeHidrometros.isNull()) {
            aQuantidadeHidrometros.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getQuantidadeHidrometros() {
        return aQuantidadeHidrometros;
    }
    
    public DomInteger oldQuantidadeHidrometros() {
        return oQuantidadeHidrometros;
    }
    
    public Integer valueOfQuantidadeHidrometros() {
        return aQuantidadeHidrometros.getValue();
    }
    
    public boolean isQuantidadeHidrometrosModified() {
        return aQuantidadeHidrometros.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PLANO_EXECUCAO_ID">
    
    public EntSolicitacaoEnsaio planoExecucaoId(Long value) {
        setPlanoExecucaoId(value);
        return this;
    }
    
    public void setPlanoExecucaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyPlanoExecucaoId();
        } else {
            aPlanoExecucaoId.setValue(value.getValue());
            if (aPlanoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPlanoExecucaoId(String value) {
        if (value == null) {
            nullifyPlanoExecucaoId();
        } else {
            aPlanoExecucaoId.setValue(value);
            if (aPlanoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPlanoExecucaoId(Long value) {
        aPlanoExecucaoId.setValue(value);
        if (aPlanoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setPlanoExecucaoId(Object value) {
        aPlanoExecucaoId.setValue(value);
        if (aPlanoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPlanoExecucaoId() {
        if (!aPlanoExecucaoId.isNull()) {
            aPlanoExecucaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getPlanoExecucaoId() {
        return aPlanoExecucaoId;
    }
    
    public DomId oldPlanoExecucaoId() {
        return oPlanoExecucaoId;
    }
    
    public Long valueOfPlanoExecucaoId() {
        return aPlanoExecucaoId.getValue();
    }
    
    public boolean isPlanoExecucaoIdModified() {
        return aPlanoExecucaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SITUACAO">
    
    public EntSolicitacaoEnsaio situacao(String value) {
        setSituacao(value);
        return this;
    }
    
    public void setSituacao(DomOption value) {
        if (value == null || value.isNull()) {
            nullifySituacao();
        } else {
            aSituacao.setValue(value.getValue());
            if (aSituacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacao(String value) {
        if (value == null) {
            nullifySituacao();
        } else {
            aSituacao.setValue(value);
            if (aSituacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacao(Object value) {
        aSituacao.setValue(value);
        if (aSituacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySituacao() {
        if (!aSituacao.isNull()) {
            aSituacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomOption getSituacao() {
        return aSituacao;
    }
    
    public DomOption oldSituacao() {
        return oSituacao;
    }
    
    public String valueOfSituacao() {
        return aSituacao.getValue();
    }
    
    public boolean isSituacaoModified() {
        return aSituacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo QUANTIDADE_HIDROMETROS_APROVADOS">
    
    public EntSolicitacaoEnsaio quantidadeHidrometrosAprovados(Integer value) {
        setQuantidadeHidrometrosAprovados(value);
        return this;
    }
    
    public void setQuantidadeHidrometrosAprovados(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyQuantidadeHidrometrosAprovados();
        } else {
            aQuantidadeHidrometrosAprovados.setValue(value.getValue());
            if (aQuantidadeHidrometrosAprovados.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosAprovados(String value) {
        if (value == null) {
            nullifyQuantidadeHidrometrosAprovados();
        } else {
            aQuantidadeHidrometrosAprovados.setValue(value);
            if (aQuantidadeHidrometrosAprovados.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosAprovados(Integer value) {
        aQuantidadeHidrometrosAprovados.setValue(value);
        if (aQuantidadeHidrometrosAprovados.isModified()) {
            setModified(true);
        }
    }
    
    public void setQuantidadeHidrometrosAprovados(Object value) {
        aQuantidadeHidrometrosAprovados.setValue(value);
        if (aQuantidadeHidrometrosAprovados.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyQuantidadeHidrometrosAprovados() {
        if (!aQuantidadeHidrometrosAprovados.isNull()) {
            aQuantidadeHidrometrosAprovados.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getQuantidadeHidrometrosAprovados() {
        return aQuantidadeHidrometrosAprovados;
    }
    
    public DomInteger oldQuantidadeHidrometrosAprovados() {
        return oQuantidadeHidrometrosAprovados;
    }
    
    public Integer valueOfQuantidadeHidrometrosAprovados() {
        return aQuantidadeHidrometrosAprovados.getValue();
    }
    
    public boolean isQuantidadeHidrometrosAprovadosModified() {
        return aQuantidadeHidrometrosAprovados.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo QUANTIDADE_HIDROMETROS_EXECUCAO">
    
    public EntSolicitacaoEnsaio quantidadeHidrometrosExecucao(Integer value) {
        setQuantidadeHidrometrosExecucao(value);
        return this;
    }
    
    public void setQuantidadeHidrometrosExecucao(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyQuantidadeHidrometrosExecucao();
        } else {
            aQuantidadeHidrometrosExecucao.setValue(value.getValue());
            if (aQuantidadeHidrometrosExecucao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosExecucao(String value) {
        if (value == null) {
            nullifyQuantidadeHidrometrosExecucao();
        } else {
            aQuantidadeHidrometrosExecucao.setValue(value);
            if (aQuantidadeHidrometrosExecucao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosExecucao(Integer value) {
        aQuantidadeHidrometrosExecucao.setValue(value);
        if (aQuantidadeHidrometrosExecucao.isModified()) {
            setModified(true);
        }
    }
    
    public void setQuantidadeHidrometrosExecucao(Object value) {
        aQuantidadeHidrometrosExecucao.setValue(value);
        if (aQuantidadeHidrometrosExecucao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyQuantidadeHidrometrosExecucao() {
        if (!aQuantidadeHidrometrosExecucao.isNull()) {
            aQuantidadeHidrometrosExecucao.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getQuantidadeHidrometrosExecucao() {
        return aQuantidadeHidrometrosExecucao;
    }
    
    public DomInteger oldQuantidadeHidrometrosExecucao() {
        return oQuantidadeHidrometrosExecucao;
    }
    
    public Integer valueOfQuantidadeHidrometrosExecucao() {
        return aQuantidadeHidrometrosExecucao.getValue();
    }
    
    public boolean isQuantidadeHidrometrosExecucaoModified() {
        return aQuantidadeHidrometrosExecucao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo QUANTIDADE_HIDROMETROS_PENDENTES">
    
    public EntSolicitacaoEnsaio quantidadeHidrometrosPendentes(Integer value) {
        setQuantidadeHidrometrosPendentes(value);
        return this;
    }
    
    public void setQuantidadeHidrometrosPendentes(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyQuantidadeHidrometrosPendentes();
        } else {
            aQuantidadeHidrometrosPendentes.setValue(value.getValue());
            if (aQuantidadeHidrometrosPendentes.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosPendentes(String value) {
        if (value == null) {
            nullifyQuantidadeHidrometrosPendentes();
        } else {
            aQuantidadeHidrometrosPendentes.setValue(value);
            if (aQuantidadeHidrometrosPendentes.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosPendentes(Integer value) {
        aQuantidadeHidrometrosPendentes.setValue(value);
        if (aQuantidadeHidrometrosPendentes.isModified()) {
            setModified(true);
        }
    }
    
    public void setQuantidadeHidrometrosPendentes(Object value) {
        aQuantidadeHidrometrosPendentes.setValue(value);
        if (aQuantidadeHidrometrosPendentes.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyQuantidadeHidrometrosPendentes() {
        if (!aQuantidadeHidrometrosPendentes.isNull()) {
            aQuantidadeHidrometrosPendentes.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getQuantidadeHidrometrosPendentes() {
        return aQuantidadeHidrometrosPendentes;
    }
    
    public DomInteger oldQuantidadeHidrometrosPendentes() {
        return oQuantidadeHidrometrosPendentes;
    }
    
    public Integer valueOfQuantidadeHidrometrosPendentes() {
        return aQuantidadeHidrometrosPendentes.getValue();
    }
    
    public boolean isQuantidadeHidrometrosPendentesModified() {
        return aQuantidadeHidrometrosPendentes.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo QUANTIDADE_HIDROMETROS_REPROVADOS">
    
    public EntSolicitacaoEnsaio quantidadeHidrometrosReprovados(Integer value) {
        setQuantidadeHidrometrosReprovados(value);
        return this;
    }
    
    public void setQuantidadeHidrometrosReprovados(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyQuantidadeHidrometrosReprovados();
        } else {
            aQuantidadeHidrometrosReprovados.setValue(value.getValue());
            if (aQuantidadeHidrometrosReprovados.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosReprovados(String value) {
        if (value == null) {
            nullifyQuantidadeHidrometrosReprovados();
        } else {
            aQuantidadeHidrometrosReprovados.setValue(value);
            if (aQuantidadeHidrometrosReprovados.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setQuantidadeHidrometrosReprovados(Integer value) {
        aQuantidadeHidrometrosReprovados.setValue(value);
        if (aQuantidadeHidrometrosReprovados.isModified()) {
            setModified(true);
        }
    }
    
    public void setQuantidadeHidrometrosReprovados(Object value) {
        aQuantidadeHidrometrosReprovados.setValue(value);
        if (aQuantidadeHidrometrosReprovados.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyQuantidadeHidrometrosReprovados() {
        if (!aQuantidadeHidrometrosReprovados.isNull()) {
            aQuantidadeHidrometrosReprovados.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getQuantidadeHidrometrosReprovados() {
        return aQuantidadeHidrometrosReprovados;
    }
    
    public DomInteger oldQuantidadeHidrometrosReprovados() {
        return oQuantidadeHidrometrosReprovados;
    }
    
    public Integer valueOfQuantidadeHidrometrosReprovados() {
        return aQuantidadeHidrometrosReprovados.getValue();
    }
    
    public boolean isQuantidadeHidrometrosReprovadosModified() {
        return aQuantidadeHidrometrosReprovados.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CODIGO">
    
    public EntSolicitacaoEnsaio codigo(String value) {
        setCodigo(value);
        return this;
    }
    
    public void setCodigo(DomText value) {
        if (value == null || value.isNull()) {
            nullifyCodigo();
        } else {
            aCodigo.setValue(value.getValue());
            if (aCodigo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCodigo(String value) {
        if (value == null) {
            nullifyCodigo();
        } else {
            aCodigo.setValue(value);
            if (aCodigo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCodigo(Object value) {
        aCodigo.setValue(value);
        if (aCodigo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCodigo() {
        if (!aCodigo.isNull()) {
            aCodigo.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getCodigo() {
        return aCodigo;
    }
    
    public DomText oldCodigo() {
        return oCodigo;
    }
    
    public String valueOfCodigo() {
        return aCodigo.getValue();
    }
    
    public boolean isCodigoModified() {
        return aCodigo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo RESERVA_SEQUENCIAS">
    
    public EntSolicitacaoEnsaio reservaSequencias(String value) {
        setReservaSequencias(value);
        return this;
    }
    
    public void setReservaSequencias(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyReservaSequencias();
        } else {
            aReservaSequencias.setValue(value.getValue());
            if (aReservaSequencias.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setReservaSequencias(String value) {
        if (value == null) {
            nullifyReservaSequencias();
        } else {
            aReservaSequencias.setValue(value);
            if (aReservaSequencias.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setReservaSequencias(Object value) {
        aReservaSequencias.setValue(value);
        if (aReservaSequencias.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyReservaSequencias() {
        if (!aReservaSequencias.isNull()) {
            aReservaSequencias.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getReservaSequencias() {
        return aReservaSequencias;
    }
    
    public DomFlag oldReservaSequencias() {
        return oReservaSequencias;
    }
    
    public String valueOfReservaSequencias() {
        return aReservaSequencias.getValue();
    }
    
    public boolean isReservaSequenciasModified() {
        return aReservaSequencias.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteCascade() throws AdsException {
        // Delete cascade ZTEST.ENSAIO_BANCADA.FK_ENBANC_SOLICITACAO_ENSAIO
        {
            EntEnsaioBancada ensaioBancada = new EntEnsaioBancada(ctx);
            ensaioBancada.del("select id from ENSAIO_BANCADA where SOLICITACAO_ENSAIO_ID = " + valueOfId());
        }
        // Delete cascade ZTEST.NUMERO_SERIE_SOLICITACAO.FK_NUSESO_SOLICITACAO_ENSAIO
        {
            EntNumeroSerieSolicitacao numeroSerieSolicitacao = new EntNumeroSerieSolicitacao(ctx);
            numeroSerieSolicitacao.del("select id from NUMERO_SERIE_SOLICITACAO where SOLICITACAO_ENSAIO_ID = " + valueOfId());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            e = new AdsException("ZTEST.SOLICITACAO_ENSAIO.GET_ERRORS_UNKNOWN",
                    AdsException.UNKNOWN,
                    "Erro não esperado: " + errorMsg);
        } else {
            if (msg.indexOf("UK_SOLENS_CODIGO") >= 0) {
                e = new AdsException("ZTEST.SOLICITACAO_ENSAIO.UK_SOLENS_CODIGO", 
                        Severity.ERROR,
                        "Registro duplicado! O código da solicitação deve ser único! Código da solicitação ${CODIGO} (UK_SOLENS_CODIGO)");
                return e;
            } else if (msg.indexOf("QUANTIDADE_HIDROMETROS_MAIOR_OU_IGUAL_EM_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.SOLICITACAO_ENSAIO.QUANTIDADE_HIDROMETROS_MAIOR_OU_IGUAL_EM_EXECUCAO", 
                        Severity.ERROR,
                        "Regra inválida! Quantidade de hidrômetros da solicitação deve ser maior ou igual da quantidade de hidrômetros em execução nos ensaios! (QUANTIDADE_HIDROMETROS_MAIOR_OU_IGUAL_EM_EXECUCAO)");
                return e;
            } else if (msg.indexOf("QUANTIDADE_HIDROMETROS_MAIOR_QUE_ZERO") >= 0) {
                e = new AdsException("ZTEST.SOLICITACAO_ENSAIO.QUANTIDADE_HIDROMETROS_MAIOR_QUE_ZERO", 
                        Severity.ERROR,
                        "Regra inválida! Quantidade de hidrômetros para testes da solicitação deve ser maior do que zero! (QUANTIDADE_HIDROMETROS_MAIOR_QUE_ZERO)");
                return e;
            } else if (msg.indexOf("UK_SOLENS_SEQUENCIA") >= 0) {
                e = new AdsException("ZTEST.SOLICITACAO_ENSAIO.UK_SOLENS_SEQUENCIA", 
                        Severity.ERROR,
                        "Registro duplicado! Sequência automática deve ser único! Sequência automática ${SEQUENCIA_AUTOMATICA} (UK_SOLENS_SEQUENCIA)");
                return e;
            } else if (msg.indexOf("FK_SOLENS_PLANO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.SOLICITACAO_ENSAIO.FK_SOLENS_PLANO_EXECUCAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para PLANO_EXECUCAO! (FK_SOLENS_PLANO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("FK_SOLENS_MODELO_HIDROMETRO") >= 0) {
                e = new AdsException("ZTEST.SOLICITACAO_ENSAIO.FK_SOLENS_MODELO_HIDROMETRO", 
                        Severity.ERROR,
                        "Registro não cadastrado para MODELO_HIDROMETRO! (FK_SOLENS_MODELO_HIDROMETRO)");
                return e;
            } else if (msg.indexOf("PK_SOLENS") >= 0) {
                e = new AdsException("ZTEST.SOLICITACAO_ENSAIO.PK_SOLENS", 
                        Severity.ERROR,
                        "ID duplicado! (PK_SOLENS)");
                return e;
            } else {
                e = new AdsException("ZTEST.SOLICITACAO_ENSAIO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aDataEnsaio);
            allAttributes.add(aDataHoraRegistro);
            allAttributes.add(aOrdemProducao);
            allAttributes.add(aOrigemSolicitacao);
            allAttributes.add(aSequenciaAutomatica);
            allAttributes.add(aModeloHidrometroId);
            allAttributes.add(aQuantidadeHidrometros);
            allAttributes.add(aPlanoExecucaoId);
            allAttributes.add(aSituacao);
            allAttributes.add(aQuantidadeHidrometrosAprovados);
            allAttributes.add(aQuantidadeHidrometrosExecucao);
            allAttributes.add(aQuantidadeHidrometrosPendentes);
            allAttributes.add(aQuantidadeHidrometrosReprovados);
            allAttributes.add(aCodigo);
            allAttributes.add(aReservaSequencias);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getSequenciaAutomatica().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findBySequenciaAutomatica(long sequenciaAutomatica) throws AdsException {
        findBy(new String[] {"SEQUENCIA_AUTOMATICA"},
                new Object[] {sequenciaAutomatica});
    }
    
    public void findByCodigo(String codigo) throws AdsException {
        findBy(new String[] {"CODIGO"},
                new Object[] {codigo});
    }
    
    private EntPlanoExecucao ePlanoExecucao;
    
    public EntPlanoExecucao findPlanoExecucao() throws AdsException {
        if (getPlanoExecucaoId().isNull()) {
            return null;
        }
        if (ePlanoExecucao == null || !valueOfPlanoExecucaoId().equals(ePlanoExecucao.valueOfId())) {
            ePlanoExecucao = new EntPlanoExecucao(ctx);
            ePlanoExecucao.find(valueOfPlanoExecucaoId());
        }
        return ePlanoExecucao;
    }
    
    /**
     * Ativa o join desta entidade com PLANO_EXECUCAO
     * através do atributo PLANO_EXECUCAO_ID
     */
    public EntPlanoExecucao joinPlanoExecucao() {
        return joinPlanoExecucao(null);
    }
    public EntPlanoExecucao joinPlanoExecucao(String alias) {
        EntPlanoExecucao entity = new EntPlanoExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getPlanoExecucaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByPlanoExecucao(long id, String sqlAppend) throws AdsException {
        find("select ID from SOLICITACAO_ENSAIO where PLANO_EXECUCAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByPlanoExecucao(long id) throws AdsException {
        findByPlanoExecucao(id,"");
    }
    
    public void findByPlanoExecucao(Entity entidade) throws AdsException {
        findByPlanoExecucao(entidade.valueOfId(),"");
    }
    
    public void findByPlanoExecucao(Entity entidade, String sqlAppend) throws AdsException {
        findByPlanoExecucao(entidade.valueOfId(),sqlAppend);
    }
    
    private EntModeloHidrometro eModeloHidrometro;
    
    public EntModeloHidrometro findModeloHidrometro() throws AdsException {
        if (getModeloHidrometroId().isNull()) {
            return null;
        }
        if (eModeloHidrometro == null || !valueOfModeloHidrometroId().equals(eModeloHidrometro.valueOfId())) {
            eModeloHidrometro = new EntModeloHidrometro(ctx);
            eModeloHidrometro.find(valueOfModeloHidrometroId());
        }
        return eModeloHidrometro;
    }
    
    /**
     * Ativa o join desta entidade com MODELO_HIDROMETRO
     * através do atributo MODELO_HIDROMETRO_ID
     */
    public EntModeloHidrometro joinModeloHidrometro() {
        return joinModeloHidrometro(null);
    }
    public EntModeloHidrometro joinModeloHidrometro(String alias) {
        EntModeloHidrometro entity = new EntModeloHidrometro(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getModeloHidrometroId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByModeloHidrometro(long id, String sqlAppend) throws AdsException {
        find("select ID from SOLICITACAO_ENSAIO where MODELO_HIDROMETRO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByModeloHidrometro(long id) throws AdsException {
        findByModeloHidrometro(id,"");
    }
    
    public void findByModeloHidrometro(Entity entidade) throws AdsException {
        findByModeloHidrometro(entidade.valueOfId(),"");
    }
    
    public void findByModeloHidrometro(Entity entidade, String sqlAppend) throws AdsException {
        findByModeloHidrometro(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        ePlanoExecucao = null;
        eModeloHidrometro = null;
    }
    /**
     * Retorna os registros de NUMERO_SERIE_SOLICITACAO que referenciam este registro através do atributo SOLICITACAO_ENSAIO_ID
     */
    public EntNumeroSerieSolicitacao findAllNumeroSerieSolicitacaoSolicitacaoEnsaio() throws AdsException {
        return findAllNumeroSerieSolicitacaoSolicitacaoEnsaio("order by ID");
    }
    
    /**
     * Retorna os registros de NUMERO_SERIE_SOLICITACAO que referenciam este registro através do atributo SOLICITACAO_ENSAIO_ID
     */
    public EntNumeroSerieSolicitacao findAllNumeroSerieSolicitacaoSolicitacaoEnsaio(String sqlAppend) throws AdsException {
        EntNumeroSerieSolicitacao out = new EntNumeroSerieSolicitacao(ctx);
        out.find("select ID from NUMERO_SERIE_SOLICITACAO where SOLICITACAO_ENSAIO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de ENSAIO_BANCADA que referenciam este registro através do atributo SOLICITACAO_ENSAIO_ID
     */
    public EntEnsaioBancada findAllEnsaioBancadaSolicitacaoEnsaio() throws AdsException {
        return findAllEnsaioBancadaSolicitacaoEnsaio("order by ID");
    }
    
    /**
     * Retorna os registros de ENSAIO_BANCADA que referenciam este registro através do atributo SOLICITACAO_ENSAIO_ID
     */
    public EntEnsaioBancada findAllEnsaioBancadaSolicitacaoEnsaio(String sqlAppend) throws AdsException {
        EntEnsaioBancada out = new EntEnsaioBancada(ctx);
        out.find("select ID from ENSAIO_BANCADA where SOLICITACAO_ENSAIO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oReservaSequencias.setValue(aReservaSequencias);
        oCodigo.setValue(aCodigo);
        oSituacao.setValue(aSituacao);
        oQuantidadeHidrometrosReprovados.setValue(aQuantidadeHidrometrosReprovados);
        oQuantidadeHidrometrosExecucao.setValue(aQuantidadeHidrometrosExecucao);
        oQuantidadeHidrometrosPendentes.setValue(aQuantidadeHidrometrosPendentes);
        oQuantidadeHidrometrosAprovados.setValue(aQuantidadeHidrometrosAprovados);
        oSequenciaAutomatica.setValue(aSequenciaAutomatica);
        oPlanoExecucaoId.setValue(aPlanoExecucaoId);
        oOrigemSolicitacao.setValue(aOrigemSolicitacao);
        oQuantidadeHidrometros.setValue(aQuantidadeHidrometros);
        oModeloHidrometroId.setValue(aModeloHidrometroId);
        oOrdemProducao.setValue(aOrdemProducao);
        oDataHoraRegistro.setValue(aDataHoraRegistro);
        oDataEnsaio.setValue(aDataEnsaio);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntSolicitacaoEnsaio.class);
            rule.setName("PK_SOLENS");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntSolicitacaoEnsaio.class);
            rule.setAssociatedEntity(EntModeloHidrometro.class);
            rule.setName("FK_SOLENS_MODELO_HIDROMETRO");
            rule.addAttribute(new DomId("MODELO_HIDROMETRO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntSolicitacaoEnsaio.class);
            rule.setAssociatedEntity(EntPlanoExecucao.class);
            rule.setName("FK_SOLENS_PLANO_EXECUCAO");
            rule.addAttribute(new DomId("PLANO_EXECUCAO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntSolicitacaoEnsaio.class);
            rule.setName("UK_SOLENS_SEQUENCIA");
            rule.addAttribute(new DomId("SEQUENCIA_AUTOMATICA",""));
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntSolicitacaoEnsaio.class);
            rule.setCheckAttribute(new DomOption("ORIGEM_SOLICITACAO",""));
            rule.setName("CKAV_20399738");
            rule.addAllowableValues(new String[] {"T", "O"});
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntSolicitacaoEnsaio.class);
            rule.setName("UK_SOLENS_CODIGO");
            rule.addAttribute(new DomText("CODIGO",""));
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntSolicitacaoEnsaio.class);
            rule.setCheckAttribute(new DomOption("SITUACAO",""));
            rule.setName("CKAV_20903562");
            rule.addAllowableValues(new String[] {"P", "E", "F"});
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void preInsert() throws AdsException {
        calcularOrigemSolicitacao(); //Calcular a origem da solicitação
        calcularSituacaoSolicitacao(); //Calcular situação da solicitação
        calcularCodigoSolicitacao(); //Calcular o código da solicitação de ensaio
        reservarSequenciasNumerosProdutos(); //Reservar sequencias de números de produtos
        checkRule(isQuantidadeHidrometrosMaiorQueZeroValid(), "QUANTIDADE_HIDROMETROS_MAIOR_QUE_ZERO", "Quantidade de hidrômetros para testes da solicitação deve ser maior do que zero!");
    }
    
    @Override
    protected void preUpdate() throws AdsException {
        calcularOrigemSolicitacao(); //Calcular a origem da solicitação
        calcularSituacaoSolicitacao(); //Calcular situação da solicitação
        calcularCodigoSolicitacao(); //Calcular o código da solicitação de ensaio
        reservarSequenciasNumerosProdutos(); //Reservar sequencias de números de produtos
        controlarAlteracaoQtdeSolicitada(); //Controlar alteração da qtde solicitada
        checkRule(isQuantidadeHidrometrosMaiorOuIgualEmExecucaoValid(), "QUANTIDADE_HIDROMETROS_MAIOR_OU_IGUAL_EM_EXECUCAO", "Quantidade de hidrômetros da solicitação deve ser maior ou igual da quantidade de hidrômetros em execução nos ensaios!");
        checkRule(isQuantidadeHidrometrosMaiorQueZeroValid(), "QUANTIDADE_HIDROMETROS_MAIOR_QUE_ZERO", "Quantidade de hidrômetros para testes da solicitação deve ser maior do que zero!");
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aSequenciaAutomatica.isNull()) {
            aSequenciaAutomatica.setValue("" + ctx.getNextVal("seq_solicitacoes"));
        }
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getReservaSequencias().isNull()) {
            setReservaSequencias(getReservaSequencias().getDefaultValue());
        }
        if (getSituacao().isNull()) {
            setSituacao(getSituacao().getDefaultValue());
        }
        if (getQuantidadeHidrometrosReprovados().isNull()) {
            setQuantidadeHidrometrosReprovados(getQuantidadeHidrometrosReprovados().getDefaultValue());
        }
        if (getQuantidadeHidrometrosExecucao().isNull()) {
            setQuantidadeHidrometrosExecucao(getQuantidadeHidrometrosExecucao().getDefaultValue());
        }
        if (getQuantidadeHidrometrosPendentes().isNull()) {
            setQuantidadeHidrometrosPendentes(getQuantidadeHidrometrosPendentes().getDefaultValue());
        }
        if (getQuantidadeHidrometrosAprovados().isNull()) {
            setQuantidadeHidrometrosAprovados(getQuantidadeHidrometrosAprovados().getDefaultValue());
        }
        if (getOrigemSolicitacao().isNull()) {
            setOrigemSolicitacao(getOrigemSolicitacao().getDefaultValue());
        }
        if (getDataHoraRegistro().isNull()) {
            setDataHoraRegistro(getDataHoraRegistro().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Regra de validação: Quantidade de hidrômetros para testes da solicitação deve ser maior do que zero!
     */
    private Object isQuantidadeHidrometrosMaiorQueZeroValid() throws AdsException {
        // <user-code id="21759795" parentId="21759781" hashcode="796859ee" length="42">
        return valueOfQuantidadeHidrometros() > 0;
        // </user-code>
    }
    
    /**
     * Regra de validação: Quantidade de hidrômetros da solicitação deve ser maior ou igual da quantidade de hidrômetros em execução nos ensaios!
     */
    private Object isQuantidadeHidrometrosMaiorOuIgualEmExecucaoValid() throws AdsException {
        // <user-code id="21759955" parentId="21759869" hashcode="-4a963339" length="213">
        if (isQuantidadeHidrometrosModified()) {
            return (valueOfQuantidadeHidrometrosExecucao() 
                    + valueOfQuantidadeHidrometrosAprovados()) < valueOfQuantidadeHidrometros();
                   
        }
        return true;
        // </user-code>
    }
    
    /**
     * Regra de ação: Calcular o código da solicitação de ensaio
     */
    private void calcularCodigoSolicitacao() throws AdsException {
        // <user-code id="21756733" parentId="21756669" hashcode="9bdd855" length="331">
        if (isOrdemProducaoModified() || getOrdemProducao().isNull()) {
            if (getOrdemProducao().isNull()) {
                if (aId.isNull()) {
                    aId.setValue("" + ctx.getNextVal("pk_sequence"));
                }
                setCodigo("S-" + valueOfId().longValue());
            } else {
                setCodigo(getOrdemProducao().toText());
            }
        }
        // </user-code>
    }
    
    /**
     * Regra de ação: Reservar sequencias de números de produtos
     */
    private void reservarSequenciasNumerosProdutos() throws AdsException {
        // <user-code id="21883712" parentId="21883627" hashcode="-10d0148f" length="1339">
        //--
        // código invalidados, rever    
        /*
        if (isQtdeSequenciasReservarModified()) {
            if (oldQtdeSequenciasReservar().isNotNull() && valueOfQtdeSequenciasReservar() > 0) {
                ctx.pushError(ENTITY_NAME,
                        Severity.ERROR,
                        "Quantidade de sequencias para reservar não pode ser alterada, pois já foram alocadas!");
            } else {
                boolean temErro = false;
                if (findModeloHidrometro().getVazaoPrefixoSerieId().isNull()) {
                    temErro = true;
                } else {
                    try {
                        EntVazaoPrefixoSerie vazaoSerie = findModeloHidrometro().findVazaoPrefixoSerie();
                        setSequenciaCorrenteInicial(vazaoSerie.valueOfProximaSequenciaProduto());
        
                        vazaoSerie.getProximaSequenciaProduto().add(valueOfQtdeSequenciasReservar());
                        vazaoSerie.setModified(true);
                        vazaoSerie.upd();
                        vazaoSerie.close();
                    } catch (RecordNotFoundException e) {
                        temErro = true;
                    }
                }
                    
                if (temErro) {
                    ctx.pushError(ENTITY_NAME,
                            Severity.ERROR,
                            "Vazão informada no modelo de hidrômentro não cadastrada! Revise o cadastro de vazão e série e o cadastro deste modelo.");
                }
            }
        }
        */
        // </user-code>
    }
    
    /**
     * Regra de ação: Calcular a origem da solicitação
     */
    private void calcularOrigemSolicitacao() throws AdsException {
        // <user-code id="20815690" parentId="20815643" hashcode="3a9f33e3" length="113">
        if (getOrdemProducao().isNull()) {
            setOrigemSolicitacao("T");
        } else {
            setOrigemSolicitacao("O");
        }
        
        // </user-code>
    }
    
    /**
     * Regra de ação: Calcular situação da solicitação
     */
    private void calcularSituacaoSolicitacao() throws AdsException {
        // <user-code id="20903534" parentId="20903533" hashcode="41da67e5" length="413">
        if (isQuantidadeHidrometrosAprovadosModified() || isQuantidadeHidrometrosReprovadosModified()) {
            if (valueOfQuantidadeHidrometros() == 
                    (valueOfQuantidadeHidrometrosAprovados() + valueOfQuantidadeHidrometrosReprovados())) {
                setSituacao("F");
            } else if ((valueOfQuantidadeHidrometrosAprovados() + valueOfQuantidadeHidrometrosReprovados()) > 0) {
                setSituacao("E");
            }
        }
        // </user-code>
    }
    
    /**
     * Regra de ação: Controlar alteração da qtde solicitada
     * 
     * Alterar a quantidade da solicitação para maior, somente se não houver 
     * outra solicitação de mesma vazão que já teve sequências alocadas.
     */
    private void controlarAlteracaoQtdeSolicitada() throws AdsException {
        // <user-code id="22045389" parentId="22045143" hashcode="-7c831f4a" length="29">
        // TODO, implementar...
        //--
        // </user-code>
    }
}
